package ormdb

import (
	"fmt"
	"time"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

// 初始化完成标记
var IsInitOk = false

// 数据库名->数据库指针
var SourceDbConnName2Ptr = make(map[string]*gorm.DB)

// 数据库名->数据库指针
var DestinationDbConnName2Ptr = make(map[string]*gorm.DB)

// 初始化配置文件里面的数据库到map中
func InitDb(dbId string, mysqlConnStr string, wherePtr int) (err error) {

	fmt.Printf("{InitDb dbId^mysqlConnStr}|%s|%s\n", dbId, mysqlConnStr)
	dbPtr, err := gorm.Open(mysql.Open(mysqlConnStr), &gorm.Config{})
	if err != nil {
		fmt.Printf("{initDbError dbId^err}|%s|%s\n", dbId, err.Error())
	} else {
		//连接池配置
		//这个sqlDb和dbPtr这个不一样 前者是sql.DB 后者 是gorm.DB sql.DB为通用数据库接口
		sqlDb, _ := dbPtr.DB()
		sqlDb.SetMaxIdleConns(30)                 //设置空闲连接池中连接的最大数量
		sqlDb.SetMaxOpenConns(100)                //设置打开数据库连接的最大数量
		sqlDb.SetConnMaxLifetime(3 * time.Minute) //设置连接复用时间

		if wherePtr == 0 {
			SourceDbConnName2Ptr[dbId] = dbPtr
		} else {
			DestinationDbConnName2Ptr[dbId] = dbPtr
		}
	}

	IsInitOk = true
	return nil
}

func Output() {
	fmt.Println("---------------DbConnName2PtrOutput---------------")
	// 遍历 map，输出每个键和值
	for key, value := range SourceDbConnName2Ptr {
		fmt.Printf("{SourceDbConnName2Ptr}|Key: %s, Value: %+v\n", key, value)
	}
	// 遍历 map，输出每个键和值
	for key, value := range DestinationDbConnName2Ptr {
		fmt.Printf("{DestinationDbConnName2Ptr}|Key: %s, Value: %+v\n", key, value)
	}
}

func GetSourceDb(dbConnName string) (*gorm.DB, error) {
	dbConnPtr, ok := SourceDbConnName2Ptr[dbConnName]
	if !ok {
		// 键不存在，进行处理
		return nil, fmt.Errorf("%s Not Found", dbConnName)
	}
	// 键存在，可以安全地访问值
	return dbConnPtr, nil
}

func GetDestinationDb(dbConnName string) (*gorm.DB, error) {
	dbConnPtr, ok := DestinationDbConnName2Ptr[dbConnName]
	if !ok {
		// 键不存在，进行处理
		return nil, fmt.Errorf("%s Not Found", dbConnName)
	}
	// 键存在，可以安全地访问值
	return dbConnPtr, nil
}

/** 定义time类型 **/
/*
// Time is alias type for time.Time
type Time time.Time

const (
	timeFormart = "2006-01-02 15:04:05"
	zone        = "Asia/Shanghai"
)

// UnmarshalJSON implements jsonspider unmarshal interface.
func (t *Time) UnmarshalJSON(data []byte) (err error) {
	now, err := time.ParseInLocation(`"`+timeFormart+`"`, string(data), time.Local)
	*t = Time(now)
	return
}

// MarshalJSON implements jsonspider marshal interface.
func (t Time) MarshalJSON() ([]byte, error) {
	b := make([]byte, 0, len(timeFormart)+2)
	b = append(b, '"')
	b = time.Time(t).AppendFormat(b, timeFormart)
	b = append(b, '"')
	return b, nil
}

func (t Time) String() string {
	return time.Time(t).Format(timeFormart)
}

func (t Time) local() time.Time {
	loc, _ := time.LoadLocation(zone)
	return time.Time(t).In(loc)
}

// Value ...
func (t Time) Value() (driver.Value, error) {
	var zeroTime time.Time
	var ti = time.Time(t)
	if ti.UnixNano() == zeroTime.UnixNano() {
		return nil, nil
	}
	return ti, nil
}

// Scan valueof time.Time 注意是指针类型 method
func (t *Time) Scan(v interface{}) error {
	value, ok := v.(time.Time)
	if ok {
		*t = Time(value)
		return nil
	}
	return fmt.Errorf("can not convert %+v to timestamp", v)
}
*/
